home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet multimedia / Animacje, filmy i prezentacje / Modelowanie 3D / K-3D 0.6.5.0 / k3d-all-in-one-setup-0.6.5.0.exe / aqsis-setup-1.1.0-2006-12-09.exe / include / aqsis / vector3d.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-06-14  |  8.6 KB  |  363 lines
  1. // Aqsis
  2. // Copyright ⌐ 1997 - 2001, Paul C. Gregory
  3. //
  4. // Contact: pgregory@aqsis.org
  5. //
  6. // This library is free software; you can redistribute it and/or
  7. // modify it under the terms of the GNU General Public
  8. // License as published by the Free Software Foundation; either
  9. // version 2 of the License, or (at your option) any later version.
  10. //
  11. // This library is distributed in the hope that it will be useful,
  12. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14. // General Public License for more details.
  15. //
  16. // You should have received a copy of the GNU General Public
  17. // License along with this library; if not, write to the Free Software
  18. // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19.  
  20.  
  21. /** \file
  22.         \brief Declares the CqVector3D class which encapsulates a 3D vector/point/normal.
  23.         \author Paul C. Gregory (pgregory@aqsis.org)
  24. */
  25.  
  26. //? Is .h included already?
  27. #ifndef VECTOR3D_H_INCLUDED
  28. #define VECTOR3D_H_INCLUDED 1
  29.  
  30. #include    <iostream>
  31.  
  32. #include    "aqsis.h"
  33.  
  34. #include    "vector2d.h"
  35.  
  36. START_NAMESPACE( Aqsis )
  37.  
  38. //-----------------------------------------------------------------------
  39.  
  40. class CqVector4D;
  41. class CqColor;
  42.  
  43. //----------------------------------------------------------------------
  44. /** \class CqVector3D
  45.  * \brief Define class structure for 3D vector.
  46.  */
  47.  
  48. class CqVector3D
  49. {
  50.     public:
  51.         CqVector3D() : m_x(0.0f), m_y(0.0f), m_z(0.0f)
  52.         {}
  53.         CqVector3D( const CqVector2D &From ) : m_x( From.x() ), m_y( From.y() ), m_z( 0 )
  54.         {}
  55.         CqVector3D( const CqColor &From );
  56.         CqVector3D( TqFloat x, TqFloat y, TqFloat z ) : m_x( x ), m_y( y ), m_z( z )
  57.         {}
  58.         CqVector3D( TqFloat f ) : m_x( f ), m_y( f ), m_z( f )
  59.         {}
  60.         CqVector3D( const CqVector4D &From );
  61.         CqVector3D( const TqFloat Array[ 3 ] ) : m_x( Array[ 0 ] ), m_y( Array[ 1 ] ), m_z( Array[ 2 ] )
  62.         {}
  63.         ~CqVector3D()
  64.         {}
  65.  
  66.         /** Get the x component.
  67.          */
  68.         TqFloat    x() const
  69.         {
  70.             return ( m_x );
  71.         }
  72.         /** Set the x component.
  73.          */
  74.         void    x( TqFloat x )
  75.         {
  76.             m_x = x;
  77.         }
  78.         /** Get the y component.
  79.          */
  80.         TqFloat    y() const
  81.         {
  82.             return ( m_y );
  83.         }
  84.         /** Set the y component.
  85.          */
  86.         void    y( TqFloat y )
  87.         {
  88.             m_y = y;
  89.         }
  90.         /** Get the z component.
  91.          */
  92.         TqFloat    z() const
  93.         {
  94.             return ( m_z );
  95.         }
  96.         /** Set the z component.
  97.          */
  98.         void    z( TqFloat z )
  99.         {
  100.             m_z = z;
  101.         }
  102.  
  103.         /** Array based component access.
  104.          * \param i Integer component index, 0-2.
  105.          * \return Appropriate component, or z if index is invalid.
  106.          */
  107.         TqFloat&    operator[] ( TqInt i )
  108.         {
  109.             switch ( i )
  110.             {
  111.                 case 0:
  112.                     return ( m_x );
  113.                     break;
  114.                 case 1:
  115.                     return ( m_y );
  116.                     break;
  117.                 case 2:
  118.                     return ( m_z );
  119.                     break;
  120.                 default:
  121.                     break;
  122.             }
  123.             return ( m_z );
  124.         }
  125.  
  126.         /** Array based component access.
  127.          * \param i Integer component index, 0-2.
  128.          * \return Appropriate component, or z if index is invalid.
  129.          */
  130.         const TqFloat&    operator[] ( TqInt i ) const
  131.         {
  132.             switch ( i )
  133.             {
  134.                 case 0:
  135.                     return ( m_x );
  136.                     break;
  137.                 case 1:
  138.                     return ( m_y );
  139.                     break;
  140.                 case 2:
  141.                     return ( m_z );
  142.                     break;
  143.                 default:
  144.                     break;
  145.             }
  146.             return ( m_z );
  147.         }
  148.  
  149.         /** Get the length squared.
  150.          */
  151.         TqFloat    Magnitude2() const
  152.         {
  153.             return ( ( m_x * m_x ) + ( m_y * m_y ) + ( m_z * m_z ) );
  154.         }
  155.         /** Get the length.
  156.          */
  157.         TqFloat    Magnitude() const
  158.         {
  159.             TqFloat mag2 = Magnitude2();
  160.             return ( mag2<=0.0f? 0.0f : sqrt( mag2 ) );
  161.         }
  162.         CqVector3D&    Unit()
  163.         {
  164.             TqFloat Mag = Magnitude();
  165.             if( Mag > 0.0f )
  166.             {
  167.                 m_x /= Mag;
  168.                 m_y /= Mag;
  169.                 m_z /= Mag;
  170.             }
  171.             return(*this);
  172.         }
  173.  
  174.         CqVector3D& operator= ( const CqVector4D &From );
  175.         CqVector3D& operator= ( const CqColor &From );
  176.         /** Addition assignment operator.
  177.          */
  178.         CqVector3D& operator+=( const CqVector3D &From )
  179.         {
  180.             m_x += From.m_x;
  181.             m_y += From.m_y;
  182.             m_z += From.m_z;
  183.             return ( *this );
  184.         }
  185.         /** Component wise addition assignment operator.
  186.          */
  187.         CqVector3D& operator+=( const TqFloat f )
  188.         {
  189.             m_x += f;
  190.             m_y += f;
  191.             m_z += f;
  192.             return ( *this );
  193.         }
  194.         /** Subtraction assignment operator.
  195.          */
  196.         CqVector3D& operator-=( const CqVector3D &From )
  197.         {
  198.             m_x -= From.m_x;
  199.             m_y -= From.m_y;
  200.             m_z -= From.m_z;
  201.             return ( *this );
  202.         }
  203.         /** Component wise subtraction assignment operator.
  204.          */
  205.         CqVector3D& operator-=( const TqFloat f )
  206.         {
  207.             m_x -= f;
  208.             m_y -= f;
  209.             m_z -= f;
  210.             return ( *this );
  211.         }
  212.         CqVector3D& operator%=( const CqVector3D &From );
  213.         /** Component wise scale assignment operator.
  214.          */
  215.         CqVector3D& operator*=( const TqFloat Scale )
  216.         {
  217.             m_x *= Scale;
  218.             m_y *= Scale;
  219.             m_z *= Scale;
  220.             return ( *this );
  221.         }
  222.         /** Scale assignment operator.
  223.          */
  224.         CqVector3D& operator*=( const CqVector3D &Scale )
  225.         {
  226.             m_x *= Scale.m_x;
  227.             m_y *= Scale.m_y;
  228.             m_z *= Scale.m_z;
  229.             return ( *this );
  230.         }
  231.         /** Inverse scale assignment operator.
  232.          */
  233.         CqVector3D& operator/=( const CqVector3D &Scale )
  234.         {
  235.             m_x /= Scale.m_x;
  236.             m_y /= Scale.m_y;
  237.             m_z /= Scale.m_z;
  238.             return ( *this );
  239.         }
  240.         /** Component wise inverse scale assignment operator.
  241.          */
  242.         CqVector3D& operator/=( const TqFloat Scale )
  243.         {
  244.             m_x /= Scale;
  245.             m_y /= Scale;
  246.             m_z /= Scale;
  247.             return ( *this );
  248.         }
  249.  
  250.         /** Component wise equality operator.
  251.          */
  252.         TqBool    operator==( const CqVector3D &Cmp ) const
  253.         {
  254.             return ( ( m_x == Cmp.m_x ) && ( m_y == Cmp.m_y ) && ( m_z == Cmp.m_z ) );
  255.         }
  256.         /** Component wise inequality operator.
  257.          */
  258.         TqBool    operator!=( const CqVector3D &Cmp ) const
  259.         {
  260.             return ( ( m_x != Cmp.m_x ) || ( m_y != Cmp.m_y ) || ( m_z != Cmp.m_z ) );
  261.         }
  262.         /** Component wise greater than or equal to operator.
  263.          */
  264.         TqBool    operator>=( const CqVector3D &Cmp ) const
  265.         {
  266.             return ( ( m_x >= Cmp.m_x ) && ( m_y >= Cmp.m_y ) && ( m_z >= Cmp.m_z ) );
  267.         }
  268.         /** Component wise less than or equal to operator.
  269.          */
  270.         TqBool    operator<=( const CqVector3D &Cmp ) const
  271.         {
  272.             return ( ( m_x <= Cmp.m_x ) && ( m_y <= Cmp.m_y ) && ( m_z <= Cmp.m_z ) );
  273.         }
  274.         /** Component wise greater than operator.
  275.          */
  276.         TqBool    operator>( const CqVector3D &Cmp ) const
  277.         {
  278.             return ( ( m_x > Cmp.m_x ) && ( m_y > Cmp.m_y ) && ( m_z > Cmp.m_z ) );
  279.         }
  280.         /** Component wise less than operator.
  281.          */
  282.         TqBool    operator<( const CqVector3D &Cmp ) const
  283.         {
  284.             return ( ( m_x < Cmp.m_x ) && ( m_y < Cmp.m_y ) && ( m_z < Cmp.m_z ) );
  285.         }
  286.  
  287.         friend CqVector3D    operator+( const TqFloat f, const CqVector3D& v )
  288.         {
  289.             return CqVector3D( f + v.x(), f + v.y(), f + v.z() );
  290.         }
  291.         friend CqVector3D    operator+( const CqVector3D& v, const TqFloat f )
  292.         {
  293.             CqVector3D r( v );
  294.             return ( r += f );
  295.         }
  296.         friend CqVector3D    operator-( const TqFloat f, const CqVector3D& v )
  297.         {
  298.             return CqVector3D( f -v.x(), f - v.y(), f - v.z() );
  299.         }
  300.         friend CqVector3D    operator-( const CqVector3D& v, const TqFloat f )
  301.         {
  302.             CqVector3D r( v );
  303.             return ( r -= f );
  304.         }
  305.         friend CqVector3D    operator*( const TqFloat f, const CqVector3D& v )
  306.         {
  307.             return CqVector3D( f * v.x(), f * v.y(), f * v.z() );
  308.         }
  309.         friend CqVector3D    operator*( const CqVector3D& v, const TqFloat f )
  310.         {
  311.             CqVector3D r( v );
  312.             return ( r *= f );
  313.         }
  314.         friend CqVector3D    operator/( const TqFloat f, const CqVector3D& v )
  315.         {
  316.             return CqVector3D( f / v.x(), f / v.y(), f / v.z() );
  317.         }
  318.         friend CqVector3D    operator/( const CqVector3D& v, const TqFloat f )
  319.         {
  320.             CqVector3D r( v );
  321.             return ( r /= f );
  322.         }
  323.  
  324.         friend CqVector3D    operator+( const CqVector3D& a, const CqVector3D& b )
  325.         {
  326.             CqVector3D r( a );
  327.             return ( r += b );
  328.         }
  329.         friend CqVector3D    operator-( const CqVector3D& a, const CqVector3D& b )
  330.         {
  331.             CqVector3D r( a );
  332.             return ( r -= b );
  333.         }
  334.         friend CqVector3D    operator/( const CqVector3D& a, const CqVector3D& b )
  335.         {
  336.             CqVector3D r( a );
  337.             return ( r /= b );
  338.         }
  339.         friend CqVector3D    operator-( const CqVector3D& v )
  340.         {
  341.             return ( CqVector3D( -v.m_x, -v.m_y, -v.m_z ) );
  342.         } // Negation
  343.  
  344.         friend TqFloat    operator*( const CqVector3D& a, const CqVector3D& b )
  345.         {
  346.             return ( a.m_x * b.m_x + a.m_y * b.m_y + a.m_z * b.m_z );
  347.         } // Dot product
  348.         friend CqVector3D    operator%( const CqVector3D& a, const CqVector3D& b );    // X product
  349.         friend std::ostream &operator<<( std::ostream &Stream, const CqVector3D &Vector );
  350.  
  351.     protected:
  352.         TqFloat    m_x;    ///< X component.
  353.         TqFloat    m_y;    ///< Y component.
  354.         TqFloat    m_z;    ///< Z component.
  355. }
  356. ;
  357.  
  358. //-----------------------------------------------------------------------
  359.  
  360. END_NAMESPACE( Aqsis )
  361.  
  362. #endif    // VECTOR3D_H_INCLUDED
  363.